Перейти к основному содержимому

5.13. Экосистема Rust-приложений

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ
Разработчику Архитектору

Экосистема Rust-приложений​

Rust — это язык системного программирования, сочетающий безопасность памяти, высокую производительность и выразительность. Его экосистема охватывает широкий спектр областей: от встраиваемых систем до веб-серверов, от настольных приложений до блокчейн-платформ. Эта глава представляет собой подробный обзор ключевых компонентов, фреймворков, библиотек и инструментов, формирующих современную экосистему Rust-приложений. Каждый элемент рассматривается через призму его назначения, архитектурных особенностей, типичных сценариев использования и взаимодействия с другими частями экосистемы.

1. Прикладные фреймворки и клиентские приложения​

Клиентские приложения на Rust становятся всё более популярными благодаря сочетанию производительности, безопасности и кроссплатформенности. Экосистема предлагает несколько подходов к созданию пользовательских интерфейсов, каждый из которых ориентирован на определённые задачи и предпочтения разработчиков.

Tauri​

Tauri — это фреймворк для создания настольных приложений с использованием веб-технологий для пользовательского интерфейса и Rust для логики. Он использует системный WebView (например, WebKit на macOS, WebView2 на Windows) вместо встроенного Chromium, что делает приложения значительно легче по сравнению с Electron. Логика приложения пишется на Rust, а взаимодействие между фронтендом и бэкендом осуществляется через вызовы команд, сериализуемые через JSON.

Пример простого приложения на Tauri:

// src-tauri/src/main.rs
use tauri::command;

#[command]
fn greet(name: &str) -> String {
    format!("Привет, {}!", name)
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![greet])
        .run(tauri::generate_context!())
        .expect("Ошибка при запуске приложения");
}

В HTML-части вызов происходит так:

import { invoke } from '@tauri-apps/api/tauri';

invoke('greet', { name: 'Алексей' }).then(console.log);

Tauri поддерживает безопасную работу с файловой системой, сетью, уведомлениями и другими системными ресурсами через строго контролируемые API. Это делает его подходящим выбором для приложений, требующих высокой производительности и низкого потребления ресурсов.

Iced​

Iced — это кроссплатформенный GUI-фреймворк, вдохновлённый архитектурой Elm. Он использует реактивную модель, где состояние приложения изменяется только через сообщения, а интерфейс перерисовывается на основе этого состояния. Iced работает на основе OpenGL и поддерживает Windows, macOS, Linux, а также веб через WebAssembly.

Основные компоненты Iced:

  • Application — основной трейт, реализуемый пользователем.
  • Message — перечисление всех возможных событий.
  • update — функция, изменяющая состояние в ответ на сообщение.
  • view — функция, описывающая текущий интерфейс.

Пример:

use iced::{Application, Settings, Element, Command};

#[derive(Default)]
struct Counter {
    value: i32,
}

#[derive(Debug, Clone)]
enum Message {
    IncrementPressed,
    DecrementPressed,
}

impl Application for Counter {
    type Executor = iced::executor::Default;
    type Message = Message;
    type Flags = ();

    fn new(_flags: ()) -> (Self, Command<Message>) {
        (Counter::default(), Command::none())
    }

    fn title(&self) -> String {
        String::from("Счётчик")
    }

    fn update(&mut self, message: Message) -> Command<Message> {
        match message {
            Message::IncrementPressed => self.value += 1,
            Message::DecrementPressed => self.value -= 1,
        }
        Command::none()
    }

    fn view(&self) -> Element<Message> {
        use iced::widget::{column, button, text};
        column![
            button("+").on_press(Message::IncrementPressed),
            text(self.value).size(50),
            button("-").on_press(Message::DecrementPressed)
        ]
        .into()
    }
}

fn main() -> iced::Result {
    Counter::run(Settings::default())
}

Iced особенно удобен для приложений с чётко структурированной логикой и минимальным количеством побочных эффектов.

Slint​

Slint — это декларативный UI-фреймворк, позволяющий описывать интерфейсы с помощью собственного DSL (Domain-Specific Language), напоминающего QML. Он компилирует описание интерфейса в эффективный Rust-код и поддерживает как настольные платформы, так и микроконтроллеры с ограниченными ресурсами.

Файл интерфейса (ui.slint):

export component MainWindow inherits Window {
    width: 300px;
    height: 150px;
    Text {
        text: "Значение: " + root.counter;
        x: 20px;
        y: 40px;
    }
    Button {
        text: "+";
        clicked => { root.increment(); }
        x: 20px;
        y: 80px;
    }
}

Связь с Rust:

slint::include_modules!();

fn main() {
    let ui = MainWindow::new();
    let ui_handle = ui.as_weak();
    ui.on_increment(move || {
        let ui = ui_handle.unwrap();
        ui.set_counter(ui.get_counter() + 1);
    });
    ui.run().unwrap();
}

Slint обеспечивает высокую производительность за счёт компиляции в нативный код и минимизации аллокаций во время выполнения.

Dioxus​

Dioxus — это универсальный фреймворк для создания пользовательских интерфейсов, вдохновлённый React. Он поддерживает несколько целей: веб (через WebAssembly), настольные приложения (через Tauri или Wry), мобильные (через Expo), терминал (TUI) и даже SSR. Основная идея — использовать JSX-подобный синтаксис внутри Rust-кода.

Пример компонента:

use dioxus::prelude::*;

fn app(cx: Scope) -> Element {
    let mut count = use_state(cx, || 0);

    cx.render(rsx! {
        div {
            h1 { "Счётчик: {count}" }
            button { onclick: move |_| count += 1, "+" }
            button { onclick: move |_| count -= 1, "-" }
        }
    })
}

fn main() {
    dioxus::desktop::launch(app);
}

Dioxus предоставляет единый подход к разработке интерфейсов на разных платформах, что упрощает перенос приложений между средами.

Druid / Floem​

Druid — это экспериментальный фреймворк для создания нативных GUI-приложений, ориентированный на функциональный подход и чистоту архитектуры. Проект находится в состоянии покоя, но его преемник — Floem — продолжает развитие этой идеи. Floem использует современные графические API (например, wgpu) и стремится обеспечить высокую производительность, отзывчивость и гибкость.

Floem строит интерфейс с помощью композиции виджетов, управляемых реактивными сигналами. Он поддерживает темы, анимации и сложные макеты.

Пример (на ранней стадии развития Floem):

use floem::{
    reactive::*,
    views::*,
    View,
};

fn app_view() -> impl View {
    let count = create_signal(0);
    stack((
        label(move || format!("Счётчик: {}", count.get())),
        button(|| "Увеличить", move || count.update(|n| *n += 1)),
    ))
}

Floem ориентирован на будущее Rust-экосистемы GUI и активно развивается сообществом.

2. Серверные и фоновые службы​

Серверная разработка — одна из сильнейших областей применения Rust. Благодаря асинхронной модели выполнения, нулевой стоимости абстракций и гарантиям безопасности памяти без сборщика мусора, Rust стал популярным выбором для высоконагруженных, надёжных и эффективных серверных приложений. Экосистема предлагает множество фреймворков и библиотек, охватывающих все уровни сетевого стека.

Actix Web​

Actix Web — это высокопроизводительный веб-фреймворк, построенный на акторной модели через библиотеку Actix. Он поддерживает HTTP/1.x и HTTP/2, встроенную обработку WebSocket, middleware, маршрутизацию, сериализацию JSON и многое другое. Actix Web использует Tokio в качестве асинхронного рантайма и демонстрирует одни из лучших результатов в бенчмарках производительности (например, TechEmpower).

Пример простого сервера:

use actix_web::{web, App, HttpResponse, HttpServer, Result};

async fn greet(name: web::Path<String>) -> Result<HttpResponse> {
    Ok(HttpResponse::Ok().body(format!("Привет, {}!", name)))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().route("/greet/{name}", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Actix Web предоставляет строгую типизацию запросов и ответов, автоматическую десериализацию тел запросов через Serde, управление состоянием приложения и интеграцию с базами данных. Он подходит для микросервисов, API-шлюзов и высоконагруженных сервисов.

Axum​

Axum — это современный веб-фреймворк от команды Tokio, ориентированный на эргономику, композицию и использование стандартных типов Rust. Он построен поверх Hyper и Tower и использует систему извлечения (extractors) для декларативной обработки входящих данных.

Пример:

use axum::{
    routing::get,
    Router,
    extract::Path,
};

async fn greet(Path(name): Path<String>) -> String {
    format!("Привет, {}!", name)
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/greet/:name", get(greet));
    axum::Server::bind(&"0.0.0.0:3000".parse().unwrap())
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Axum отличается минималистичной архитектурой, отсутствием макросов в ядре и глубокой интеграцией с экосистемой Tokio. Он особенно удобен для создания RESTful API и серверов, требующих гибкой маршрутизации и middleware.

Rocket​

Rocket — это фреймворк, делающий упор на удобство разработки и безопасность по умолчанию. Он использует мощные макросы для описания маршрутов, автоматически проверяет корректность типов, заголовков и параметров запроса. Rocket поддерживает синхронный и асинхронный режимы (начиная с версии 0.5), встроенную поддержку шаблонов, CORS, cookies и форм.

Пример:

#[macro_use] extern crate rocket;

use rocket::serde::json::Json;

#[get("/hello/<name>")]
fn hello(name: &str) -> Json<&'static str> {
    Json("Привет!")
}

#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![hello])
}

Rocket автоматически генерирует документацию OpenAPI, обеспечивает строгую валидацию входных данных и предлагает «батарейки в комплекте» — всё необходимое для быстрого старта. Он идеален для прототипирования и средних по сложности сервисов.

Warp​

Warp — это композиционный веб-фреймворк, основанный на концепции «фильтров». Каждый фильтр представляет собой преобразователь потока запросов, который может извлекать данные, проверять условия или модифицировать запрос. Фильтры комбинируются с помощью операторов, что позволяет строить сложные маршруты декларативно.

Пример:

use warp::Filter;

#[tokio::main]
async fn main() {
    let hello = warp::path!("hello" / String)
        .map(|name| format!("Привет, {}!", name));

    warp::serve(hello)
        .run(([127, 0, 0, 1], 3030))
        .await;
}

Warp особенно силён в обработке WebSocket, streaming-ответов и сложных цепочек middleware. Его функциональный стиль подходит для разработчиков, предпочитающих композицию над императивным кодом.

Tower / Hyper​

Hyper — это низкоуровневая HTTP-библиотека, реализующая клиент и сервер. Она не является фреймворком, а предоставляет строительные блоки для создания HTTP-приложений. Tower — это набор компонентов (middleware, сервисов, утилит), совместимых с гипотезой Service из Tokio. Вместе они образуют основу для многих вышестоящих фреймворков, включая Axum и Warp.

Пример сервера на Hyper:

use hyper::{Body, Request, Response, Server};
use hyper::service::{make_service_fn, service_fn};
use std::convert::Infallible;

async fn handle(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from("Привет из Hyper!")))
}

#[tokio::main]
async fn main() {
    let make_svc = make_service_eq!(|| async { Ok::<_, Infallible>(service_fn(handle)) });
    let addr = ([127, 0, 0, 1], 3000).into();
    let server = Server::bind(&addr).serve(make_svc);
    server.await.unwrap();
}

Эти библиотеки используются, когда требуется максимальный контроль над HTTP-стеком — например, при создании прокси, шлюзов или специализированных протоколов.

Background workers — tokio::task, async-channel, sqlx + cron​

Фоновая обработка задач в Rust осуществляется с помощью асинхронных задач (tokio::task::spawn), каналов (async-channel, tokio::sync::mpsc) и планировщиков. Для периодических задач часто используется комбинация sqlx (для работы с базой данных) и крона-подобных решений, таких как tokio-cron-scheduler.

Пример фонового воркера:

use tokio::sync::mpsc;
use sqlx::PgPool;

async fn worker(mut rx: mpsc::Receiver<Task>, pool: PgPool) {
    while let Some(task) = rx.recv().await {
        // Обработка задачи
        process_task(&pool, task).await;
    }
}

async fn scheduler(tx: mpsc::Sender<Task>) {
    let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(60));
    loop {
        interval.tick().await;
        let tasks = fetch_pending_tasks().await;
        for task in tasks {
            let _ = tx.send(task).await;
        }
    }
}

Такие системы позволяют выполнять длительные операции — отправку email, обработку файлов, агрегацию данных — без блокировки основного HTTP-сервера.

3. Тестовые и вспомогательные проекты​

Качество программного обеспечения в Rust-экосистеме обеспечивается за счёт многоуровневой системы тестирования, встроенной непосредственно в язык и инструментарий. Rust предоставляет как базовые средства для написания модульных и интеграционных тестов, так и расширенные библиотеки для бенчмаркинга, мокирования, генеративного тестирования и параллельного выполнения. Эта часть экосистемы делает процесс верификации кода систематическим, воспроизводимым и эффективным.

Встроенная система тестирования (#[test])​

Rust включает в себя встроенную поддержку модульных тестов через атрибут #[test]. Тесты могут размещаться внутри модулей (внутренние тесты) или в отдельной директории tests/ (внешние интеграционные тесты). Команда cargo test автоматически находит, компилирует и запускает все функции с этим атрибутом.

Пример модульного теста:

fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }

    #[test]
    fn test_add_negative() {
        assert_eq!(add(-1, 1), 0);
    }
}

Тесты могут быть помечены атрибутами #[should_panic] для проверки ожидаемых паник, #[ignore] для пропуска тяжёлых тестов по умолчанию, а также группироваться в модули для логической организации. Cargo поддерживает фильтрацию тестов по имени, запуск в несколько потоков и вывод подробных отчётов.

Criterion.rs​

Criterion.rs — это библиотека для микро- и макробенчмаркинга, обеспечивающая статистически обоснованные результаты. Она автоматически определяет необходимое количество итераций, строит графики производительности и сравнивает изменения между версиями кода. Criterion использует собственный runner и не зависит от стандартного механизма тестов Cargo.

Пример бенчмарка:

use criterion::{criterion_group, criterion_main, Criterion};

fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 1,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn bench_fibonacci(c: &mut Criterion) {
    c.bench_function("fib 20", |b| b.iter(|| fibonacci(20)));
}

criterion_group!(benches, bench_fibonacci);
criterion_main!(benches);

После запуска cargo bench Criterion создаёт HTML-отчёты с графиками, доверительными интервалами и сравнением с предыдущими замерами. Это делает его незаменимым инструментом при оптимизации критических участков кода.

Mockall, Wiremock​

Мокирование внешних зависимостей — ключевая практика при изоляции тестируемого кода. Mockall генерирует моки для трейтов во время компиляции с помощью процедурных макросов. Он поддерживает методы с произвольными сигнатурами, возврат значений, вызов замыканий и проверку количества вызовов.

Пример:

use mockall::*;

#[automock]
trait Database {
    fn get_user(&self, id: u32) -> Option<String>;
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_with_mock() {
        let mut mock = MockDatabase::new();
        mock.expect_get_user()
            .with(eq(42))
            .returning(|_| Some("Алексей".to_string()));

        assert_eq!(mock.get_user(42), Some("Алексей".to_string()));
    }
}

Wiremock используется для мокирования HTTP-серверов. Он запускает локальный сервер, который отвечает на запросы в соответствии с заданными правилами. Это особенно полезно при тестировании клиентов, взаимодействующих с внешними API.

Пример:

use wiremock::{MockServer, Mock, ResponseTemplate};
use wiremock::matchers::{method, path};

#[tokio::test]
async fn test_http_client() {
    let mock_server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/api/user"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"name": "Алексей"})))
        .mount(&mock_server)
        .await;

    let client = reqwest::Client::new();
    let resp: serde_json::Value = client
        .get(format!("{}/api/user", mock_server.uri()))
        .send()
        .await
        .unwrap()
        .json()
        .await
        .unwrap();

    assert_eq!(resp["name"], "Алексей");
}

Proptest​

Proptest — это библиотека для генеративного (property-based) тестирования. Вместо проверки конкретных входных данных, она генерирует случайные значения в заданных диапазонах и проверяет, что свойства программы выполняются для всех случаев. Это помогает находить граничные условия и неочевидные ошибки.

Пример:

use proptest::prelude::*;

proptest! {
    #[test]
    fn test_addition_is_commutative(a: i32, b: i32) {
        prop_assert_eq!(a + b, b + a);
    }

    #[test]
    fn test_sorting_preserves_length(v: Vec<i32>) {
        let mut sorted = v.clone();
        sorted.sort();
        prop_assert_eq!(sorted.len(), v.len());
    }
}

Proptest интегрируется с Cargo и предоставляет детальные отчёты о минимальном контрпримере в случае падения теста.

Nextest​

Nextest — это современный тест-раннер, призванный заменить стандартный cargo test. Он предлагает параллельный запуск тестов с учётом ресурсов, цветной и структурированный вывод, повторный запуск упавших тестов, фильтрацию по тегам и поддержку шардов для CI. Nextest особенно эффективен в крупных проектах с сотнями или тысячами тестов.

Установка и использование:

cargo install cargo-nextest
cargo nextest run

Nextest ускоряет цикл обратной связи, минимизирует ложные срабатывания из-за таймаутов и упрощает анализ результатов в сложных средах.

4. Интеграционные и специализированные платформы​

Rust-экосистема предоставляет богатый набор библиотек для интеграции с внешними системами, обработки данных, сетевого взаимодействия и работы в специализированных средах — от встраиваемых устройств до веб-браузеров. Эти компоненты обеспечивают связность приложений, позволяют использовать Rust в нетрадиционных контекстах и расширяют границы применимости языка.

SQLx, Diesel, SeaORM​

Работа с реляционными базами данных в Rust осуществляется через несколько зрелых ORM и query-билдеров, каждый из которых предлагает свой подход к типобезопасности, производительности и удобству.

SQLx — это асинхронный, чисто Rust-овый драйвер для PostgreSQL, MySQL, SQLite и MSSQL. Он поддерживает compile-time проверку SQL-запросов: если запрос содержит синтаксическую ошибку или несоответствие типов, сборка завершится с ошибкой. Это достигается за счёт offline-режима, где макрос query! анализирует запрос на этапе компиляции.

Пример:

use sqlx::PgPool;

#[derive(sqlx::FromRow)]
struct User {
    id: i32,
    name: String,
}

async fn get_user(pool: &PgPool, id: i32) -> sqlx::Result<User> {
    sqlx::query_as!(User, "SELECT id, name FROM users WHERE id = $1", id)
        .fetch_one(pool)
        .await
}

SQLx не требует генерации кода или runtime-рефлексии, что делает его лёгким и быстрым.

Diesel — это синхронный ORM с акцентом на безопасность и производительность. Он использует макросы для генерации типобезопасных запросов и требует описания схемы базы данных в коде (через DSL или миграции). Diesel поддерживает PostgreSQL, MySQL и SQLite.

Пример:

use diesel::prelude::*;
use diesel::pg::PgConnection;

#[derive(Queryable)]
struct User {
    id: i32,
    name: String,
}

fn get_user(conn: &mut PgConnection, id: i32) -> QueryResult<User> {
    use crate::schema::users::dsl::*;
    users.find(id).first(conn)
}

Diesel особенно популярен в проектах, где важна строгая типизация и предсказуемость.

SeaORM — это асинхронный ORM, построенный поверх SQLx, сочетающий удобство ActiveRecord и DataMapper. Он поддерживает сложные отношения между сущностями, eager loading, транзакции и генерацию сущностей из существующей базы данных.

Пример:

use sea_orm::{EntityTrait, ModelTrait, DatabaseConnection};

async fn find_user(db: &DatabaseConnection, id: i32) -> Result<Option<user::Model>, DbErr> {
    user::Entity::find_by_id(id).one(db).await
}

SeaORM ориентирован на современные асинхронные приложения и предлагает высокоуровневый API без потери контроля над запросами.

Serde​

Serde — это фреймворк для сериализации и десериализации данных. Он поддерживает десятки форматов: JSON, YAML, TOML, BSON, CSV, MessagePack и другие. Serde работает на основе трейтов Serialize и Deserialize, которые могут быть автоматически выведены для структур и перечислений через атрибут #[derive(Serialize, Deserialize)].

Пример:

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Config {
    host: String,
    port: u16,
}

fn main() {
    let config = Config { host: "localhost".to_string(), port: 8080 };
    let json = serde_json::to_string(&config).unwrap();
    let parsed: Config = serde_json::from_str(&json).unwrap();
}

Serde обеспечивает нулевую стоимость абстракций: сериализация происходит напрямую в буфер без промежуточных представлений. Это делает его стандартом де-факто для работы с данными в Rust.

Tokio, async-std​

Асинхронное программирование в Rust реализуется через рантаймы. Tokio — доминирующий асинхронный рантайм, предоставляющий всё необходимое для сетевых приложений: TCP/UDP, таймеры, каналы, задачи, файловый ввод-вывод (через tokio::fs) и интеграцию с системными событиями (epoll, kqueue, IOCP). Tokio активно используется в большинстве серверных фреймворков.

async-std — альтернативный рантайм, стремящийся к максимальной совместимости со стандартной библиотекой Rust. Его API почти идентичен std, но с асинхронными аналогами (async_std::fs, async_std::net). Хотя он менее популярен, чем Tokio, он остаётся жизнеспособным выбором для проектов, ценящих простоту и единообразие.

Оба рантайма реализуют гипотезу Future и совместимы с большинством асинхронных библиотек.

WebAssembly (Wasm) — wasm-bindgen, Yew, Leptos​

Rust — один из лучших языков для компиляции в WebAssembly. Это позволяет запускать высокопроизводительный код прямо в браузере. Ключевой инструмент — wasm-bindgen — генерирует JavaScript-обёртки для вызова Rust-функций из браузера и наоборот.

Пример:

// lib.rs
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn greet(name: &str) -> String {
    format!("Привет из Rust, {}!", name)
}

После компиляции через wasm-pack функция становится доступной в JavaScript:

import { greet } from "./pkg/my_wasm_pkg.js";
console.log(greet("Алексей"));

Для создания полноценных веб-приложений используются фреймворки:

  • Yew — React-подобный фреймворк с JSX-синтаксисом и компонентной моделью.
  • Leptos — современный реактивный фреймворк, поддерживающий SSR, CSR и гибридный рендеринг. Он использует сигналы для управления состоянием и предлагает высокую производительность.

Leptos-пример:

use leptos::*;

#[component]
fn App(cx: Scope) -> impl IntoView {
    let (count, set_count) = create_signal(cx, 0);
    view! { cx,
        <div>
            <p>"Счётчик: " {count}</p>
            <button on:click=move |_| set_count.update(|n| *n += 1)>"+</button>
        </div>
    }
}

Эти технологии позволяют писать клиентские веб-приложения полностью на Rust.

Embedded Rust — HAL, RTFM, Embassy​

Встраиваемая разработка на Rust стала возможной благодаря инициативе Embedded Working Group. Основные компоненты:

  • HAL (Hardware Abstraction Layer) — набор трейтов для унифицированного доступа к периферии микроконтроллеров (GPIO, UART, SPI, I2C). Конкретные реализации предоставляются производителями (например, stm32f4xx-hal).
  • RTFM (Real-Time For the Masses) — фреймворк для реального времени, обеспечивающий статический анализ приоритетов задач и отсутствие гонок данных.
  • Embassy — современная асинхронная среда для встраиваемых систем, использующая async/await и executor на основе кооперативной многозадачности.

Пример мигания светодиодом на Embassy:

use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use embassy_stm32::gpio::{Level, Output, Speed};

#[embassy_executor::main]
async fn main(_spawner: Spawner) {
    let p = embassy_stm32::init(Default::default());
    let mut led = Output::new(p.PB7, Level::High, Speed::Low);

    loop {
        led.set_high();
        Timer::after(Duration::from_millis(500)).await;
        led.set_low();
        Timer::after(Duration::from_millis(500)).await;
    }
}

Embedded Rust обеспечивает безопасность памяти даже на устройствах без MMU, что делает его привлекательным для критически важных систем.

Networking — reqwest, awc, ureq​

Сетевые клиенты в Rust представлены несколькими библиотеками:

  • reqwest — высокоуровневый HTTP-клиент, построенный на Hyper и Tokio. Поддерживает async/await, JSON, cookies, TLS, прокси. Используется в большинстве приложений.
  • awc — HTTP-клиент из экосистемы Actix, оптимизированный для использования внутри Actix-приложений.
  • ureq — синхронный, минималистичный клиент без зависимостей от асинхронных рантаймов. Подходит для CLI-утилит и простых скриптов.

Пример reqwest:

let resp: serde_json::Value = reqwest::get("https://api.example.com/user")
    .await?
    .json()
    .await?;

Эти библиотеки покрывают все сценарии — от фоновых служб до утилит командной строки.

5. Расширения и инструменты разработки​

Инструментарий Rust играет ключевую роль в обеспечении высокого качества кода, удобства разработки и кроссплатформенной сборки. Большинство этих инструментов поставляются как часть официальной экосистемы или поддерживаются сообществом на уровне промышленных стандартов. Они формируют единый, согласованный рабочий процесс, который снижает когнитивную нагрузку и автоматизирует рутинные задачи.

Cargo​

Cargo — это система сборки и управления зависимостями, встроенная в Rust. Она управляет проектами (crates), разрешает зависимости, компилирует код, запускает тесты, генерирует документацию и публикует пакеты в реестре crates.io. Каждый проект описывается в файле Cargo.toml, где указываются метаданные, зависимости, фичи и профили сборки.

Пример Cargo.toml:

[package]
name = "my-app"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }

[dev-dependencies]
criterion = "0.5"

Cargo поддерживает workspace-проекты, custom targets, build scripts (build.rs) и conditional compilation через features. Это делает его мощным инструментом для управления сложными проектами.

Clippy​

Clippy — это расширение компилятора Rust, предоставляющее сотни линтеров для выявления распространённых ошибок, неидиоматичного кода и потенциальных проблем. Он интегрирован в rustup и запускается командой cargo clippy.

Примеры проверок:

  • Использование .clone() вместо перемещения.
  • Сравнение с true или false.
  • Недостижимый код.
  • Неэффективные аллокации.

Clippy помогает поддерживать высокий стандарт кода и обучает разработчиков лучшим практикам.

Rustfmt​

Rustfmt — это автоматический форматировщик кода, следующий официальному стилю Rust. Он применяет единообразное оформление: отступы, переносы строк, пробелы вокруг операторов. Запускается через cargo fmt.

Конфигурация может быть задана в файле rustfmt.toml:

max_width = 100
hard_tabs = false
newline_style = "Unix"

Rustfmt устраняет споры о стиле в командах и упрощает ревью кода.

Docs.rs​

Docs.rs — это сервис, автоматически генерирующий и публикующий документацию для всех пакетов на crates.io. Документация создаётся с помощью rustdoc и включает ссылки на исходный код, примеры использования, версионирование и поиск. Разработчики могут просматривать документацию любого crate по адресу https://docs.rs/crate-name.

Документация пишется в виде комментариев над элементами кода:

/// Складывает два целых числа.
/// 
/// # Пример
/// 
/// ```
/// assert_eq!(add(2, 3), 5);
/// ```
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

Docs.rs делает знания о библиотеках доступными без необходимости загрузки исходного кода.

Cross, cargo-xbuild​

Кросскомпиляция в Rust упрощена благодаря инструментам Cross и cargo-xbuild. Cross — это обёртка над Cargo, которая использует Docker для предоставления преднастроенных окружений для сборки под разные архитектуры (ARM, RISC-V, MIPS) и операционные системы (Linux, Windows, macOS, Android, iOS).

Пример:

cross build --target aarch64-unknown-linux-gnu

Это особенно важно для embedded-разработки и создания дистрибутивов.

Miri​

Miri — это интерпретатор Rust, встроенный в компилятор, предназначенный для проверки неопределённого поведения (undefined behavior) во время выполнения. Он отслеживает использование неинициализированной памяти, нарушения правил заимствования, переполнения и другие низкоуровневые ошибки.

Запуск:

cargo +nightly miri test

Miri работает медленно, но крайне эффективен для отлова тонких багов в unsafe-коде или сложных алгоритмах.

6. Экспериментальные и нишевые направления​

Rust-экосистема активно развивается не только в традиционных областях, но и в передовых, экспериментальных направлениях. Эти проекты расширяют границы применимости языка, исследуют новые парадигмы и создают основу для будущих технологий. Хотя некоторые из них находятся на ранних стадиях, они демонстрируют потенциал Rust как платформы для инноваций.

WASI (WebAssembly System Interface)​

WASI — это стандарт интерфейса системных вызовов для WebAssembly, позволяющий запускать Wasm-модули вне браузера — например, в серверных средах, CLI-утилитах или песочницах. Rust отлично подходит для компиляции в WASI благодаря своей независимости от операционной системы и отсутствию необходимости в сборщике мусора.

С помощью wasm32-wasi target можно собрать приложение:

rustup target add wasm32-wasi
cargo build --target wasm32-wasi

Полученный .wasm-файл можно запустить через runtime, такой как Wasmtime или Wasmer:

wasmtime target/wasm32-wasi/debug/my_app.wasm

WASI обеспечивает безопасную, переносимую и изолированную среду выполнения, что делает его перспективным для serverless-вычислений, плагинов и микросервисов.

GPU — wgpu, Vulkano​

Rust предлагает несколько подходов к работе с графическими процессорами. wgpu — это кроссплатформенная, безопасная обёртка над низкоуровневыми API (Vulkan, Metal, DirectX 12, WebGPU). Он предоставляет современный, идиоматичный Rust-интерфейс для рендеринга и вычислений на GPU.

Пример инициализации:

use wgpu::Instance;

let instance = Instance::new(wgpu::Backends::all());
let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions::default()).await.unwrap();
let (device, queue) = adapter.request_device(&wgpu::DeviceDescriptor::default(), None).await.unwrap();

Vulkano — это более низкоуровневая, типобезопасная привязка к Vulkan. Он использует систему типов Rust для проверки корректности использования API на этапе компиляции, предотвращая многие классы ошибок.

Эти библиотеки используются в играх, научных вычислениях, машинном обучении и визуализации данных.

Blockchain — Substrate, Solana programs​

Rust стал доминирующим языком в блокчейн-разработке благодаря своей безопасности и производительности.

Substrate — это фреймворк от Parity Technologies для создания блокчейнов. Он предоставляет модульную архитектуру (pallets), consensus engine, networking и runtime, написанный на Rust. Polkadot, Kusama и сотни других проектов построены на Substrate.

Solana использует Rust для написания программ (smart contracts). Программы компилируются в BPF (Berkeley Packet Filter) и выполняются на валидаторах. Solana SDK предоставляет макросы и утилиты для определения инструкций, аккаунтов и обработчиков.

Пример Solana-программы:

use solana_program::{
    account_info::AccountInfo,
    entrypoint,
    entrypoint::ProgramResult,
    msg,
    pubkey::Pubkey,
};

entrypoint!(process_instruction);

fn process_instruction(
    _program_id: &Pubkey,
    accounts: &[AccountInfo],
    _instruction_data: &[u8],
) -> ProgramResult {
    msg!("Привет из Solana!");
    Ok(())
}

Эти платформы делают Rust центральным элементом децентрализованной экосистемы.

Language servers — rust-analyzer​

rust-analyzer — это официальный language server для Rust, обеспечивающий интеллектуальную поддержку в редакторах (VS Code, Vim, Emacs и др.). Он предоставляет:

  • Автодополнение
  • Переход к определению
  • Поиск всех ссылок
  • Рефакторинг
  • Подсказки по типам
  • Быструю навигацию по ошибкам

rust-analyzer работает на основе полного семантического анализа кода и обновляется независимо от компилятора, что позволяет внедрять новые функции быстрее. Он стал стандартом для разработки на Rust.

Formal verification — Prusti, Kani​

Формальная верификация — это метод математического доказательства корректности программы. В Rust-экосистеме развиваются два проекта:

  • Prusti — верификатор, основанный на логике Хоара и использующий SMT-решатели. Он позволяет аннотировать функции пред- и постусловиями, а также инвариантами циклов.
  • Kani — символьный верификатор от AWS, предназначенный для проверки отсутствия паник, переполнений и других ошибок. Он генерирует формулы, которые проверяются с помощью CBMC (C Bounded Model Checker).

Пример Prusti:

#[requires(x >= 0)]
#[ensures(result >= 0)]
fn abs(x: i32) -> i32 {
    if x < 0 { -x } else { x }
}

Хотя эти инструменты пока не готовы для массового применения, они открывают путь к созданию критически важных систем с гарантиями, выходящими за рамки типовой безопасности.